import java.time.Duration;
import java.time.LocalTime;
import java.util.PriorityQueue;

class cmp1 implements Comparable<Integer> {
    int i;
    public cmp1(int i) {
        this.i = i;
    }

    @Override
    public int compareTo(Integer o) {
        return this.i - o;
    }
}

public class BitOperation {
    public static void main(String[] args) throws InterruptedException {

        PriorityQueue<cmp1> pq = new PriorityQueue<>();

        for(int i = 0; i < 10; i++) {
            cmp1 c = new cmp1(i);
            pq.add(c);
        }

        System.out.println("1: " + pq);


        LocalTime startTime = LocalTime.now();

        Long cu = System.currentTimeMillis();

        System.out.println(startTime);

        Thread.sleep(100000);

        Long cu1 = System.currentTimeMillis();

        System.out.println((cu1 - cu) / 1000 / 60);

        LocalTime endTime = LocalTime.now();

        Duration duration = Duration.between(endTime, startTime );

        System.out.println(duration.toSeconds());

        System.out.println();
    }

    /**
     *  只出现一次的数字 III
     *  因为把所有的元素^在一起之后，剩下的就一定时不一样的比特位，而这个不一样的比特位就是
     *  来自于这俩个不相同的数，而其他相同的比特位都已经被干掉了，所以就可以随便找一位为1的比特位的数字lowBit
     *  在将这个个nums和这个lowBit^在一起，不过这次要分位0和1，因为位0的表示一个为1的都是表示的时一个单的数
     */

    public int[] singleNumberIII(int[] nums) {
        int v = 0;
        for(int i : nums){
            v ^= i;
        }
        //获得最右边的1
        int lowBit = v & -v;
        int x = 0;
        int y = 0;
        for(int i : nums){
            if((i & lowBit) == 0){
                x ^= i;
            }else{
                y ^= i;
            }
        }
        return new int[]{x,y};
    }
    /**
     * 只出现一次的数字
     */
    public int singleNumber(int[] nums) {
        int v = 0;
        for(int i: nums){
            v ^= i;
        }
        return v;
    }
    /**
     * . 汉明距离
     */
    public int hammingDistance(int x, int y) {
        int ret = 0;
        int v = x ^ y;//相同为0
        while(v!=0){
            ret++;
            v &= v-1;
        }
        return ret;
    }

    /**
     * 比特位计数
     */
    public int[] countBits(int n) {
        int[] ret = new int[n+1];
        ret[0] = 0;
        for(int i = 1; i <= n; i++){
            ret[i] = getSum(i);
        }
        return ret;
    }
    int getSum(int i){
        int ret = 0;
        while(i!=0){
            i &= i-1;
            ret++;
        }
        return ret;
    }

    /**
     * 位1的个数
     */
    public int hammingWeight(int n) {
        //n & (n-1) 将最右边的1变为0
        int ret = 0;
        while(n!=0){
            n &= (n-1);
            ret++;
        }
        return ret;
    }
}
